{
  Copyright 2012, Jameel Halabi

  This unit is part of the BlaiseWave wrapper,
  which is licensed under the BSD 2-Clause license (see licenses/license.txt).
}

unit BW_Render;

{$mode delphi}{$H+}

interface

uses
  BW_Global ,

  LW_Render ,
  LW_Types  ,
  LW_Envel  ,
  LW_Meshes ;

type
  TViewType  = (vtNone       ,
                vtTop        ,
                vtBottom     ,
                vtBack       ,
                vtFront      ,
                vtRight      ,
                vtLeft       ,
                vtPerspective,
                vtLight      ,
                vtCamera     ,
                vtSchematic  ) ;

  TItemParam = (ipPosition = 1 ,
                ipRight        ,
                ipUp           ,
                ipForward      ,
                ipRotation     ,
                ipScaling      ,
                ipPivot        ,
                ipWorldPosition,
                ipWorldRight   ,
                ipWorldUp      ,
                ipWorldForward ,
                ipPivotRotation) ;

  { TListInfo }

  TListInfo = class(TGlobal)
  protected
    function GetGlobalType                   : String; override;
  public
    function Index
             (       Object_ : PLWItem ) : Integer;
    function Reorder
             (       List    : PPLWItem) : Integer;
    function Swap
             (       List    : PPLWItem) : Integer;
    function Splice
             (       Point   : PLWItem ;
                     List    : PPLWItem) : Integer;
  end;

  { TItemInfo }

  TItemInfo = class(TGlobal)
  protected
    function GetGlobalType                   : String; override;
  public
    function First
             (      Itemtype     : TLWItemType                 ;
                    BoneObject   : PLWItem                     ) : PLWItem     ;
    function Next
             (      Item         : PLWItem                     ) : PLWItem     ;
    function FirstChild
             (      Parent       : PLWItem                     ) : PLWItem     ;
    function NextChild
             (      Parent       : PLWItem                     ;
                    PrevChild    : PLWItem                     ) : PLWItem     ;
    function Parent
             (      Item         : PLWItem                     ) : PLWItem     ;
    function Target
             (      Item         : PLWItem                     ) : PLWItem     ;
    function Goal
             (      Item         : PLWItem                     ) : PLWItem     ;
    function Type_
             (      Item         : PLWItem                     ) : TLWItemType ;
    function Name
             (      Item         : PLWItem                     ) : PChar       ;
    procedure Param
              (      Item        : PLWItem                     ;
                     ParamType   : TItemParam                  ;
                     Time        : TLWTime                     ;
                 var Vector      : TLWDVector                  ) ;
    function Limits
             (       Item        : PLWItem                     ;
                     ParamType   : TLWItemParam                ;
                     Min         : TLWDVector                  ;
                     Max         : TLWDVector                  ) : UInt32      ;
    function GetTag
             (       Item        : PLWItem                     ;
                     TagNum      : Integer                     ) : PChar       ;
    procedure SetTag
              (      Item        : PLWItem                     ;
                     TagNum      : Integer                     ;
                     Tag         : PChar                       ) ;
    function ChanGroup
             (       Item        : PLWItem                     ) : PLWChanGroup;
    function Server
             (       Item        : PLWItem                     ;
                     Class_      : PChar                       ;
                     Index       : Integer                     ) : PChar       ;
    function ServerFlags
             (       Item        : PLWItem                     ;
                     Class_      : PChar                       ;
                     Index       : Integer                     ) : UInt32      ;
     procedure Controller
             (       Item        : PLWItem                     ;
                     ParamType   : TLWItemParam                ;
                     Type_       : array {[0..2]} of Integer   ) ;
    function Flags
             (      Item         : PLWItem                     ) : UInt32      ;
    function LookAhead
             (      Item         : PLWItem                     ) : TLWTime     ;
    function GoalStrength
             (      Item         : PLWItem                     ;
                    Time         : TLWTime                     ) : Double      ;
    procedure Stiffness
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ;
                    Vector       : TLWDVector                  ) ;
    function AxisLocks
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ) : UInt32      ;
    function MaxLookSteps
             (      Item         : PLWItem                     ) : UInt32      ;
    function ReliableDistance
             (      Item         : PLWItem                     ) : Double      ;
    function GoalObjective
             (      Item         : PLWItem                     ) : UInt32      ;
    function IKFKBlending
             (      Item         : PLWItem                     ;
                    Time         : TLWTime                     ) : Double      ;
    function IKInitialState
             (      Item         : PLWItem                     ) : UInt32      ;
    function IKInitialStateFrame
             (      Item         : PLWItem                     ;
                    Time         : TLWTime                     ) : TLWFrame    ;
    function IKSoft
             (      Item         : PLWItem                     ;
                    Time         : TLWTime                     ;
                    DistanceType : PUInt32                     ;
                    Min          : PDouble                     ;
                    Max          : PDouble                     ) : UInt32      ;
    function Pole
             (      Item         : PLWItem                     ) : PLWItem     ;
    function SameItem
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ) : PLWItem     ;
    function SameItemBlend
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ;
                    Time         : TLWTime                     ) : Double      ;
    function SameItemBlendMethod
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ) : UInt32      ;
    function SameItemFlags
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ) : UInt32      ;
    function Selected
             (      Item         : PLWItem                     ) : UInt32      ;
    procedure Follow
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ;
                    Follow       : array {[0..2]} of Integer   ;
                    Txtr         : array {[0..2]} of PLWTexture) ;
    procedure ControllerTrans
             (      Item         : PLWItem                     ;
                    ParamType    : TLWItemParam                ;
                    Mul          : array {[0..2]} of Double    ;
                    Add          : array {[0..2]} of Double    ) ;
  end;

  { TObjectInfo }

  TObjectInfo = class(TGlobal)
  protected
    function GetGlobalType                   : String; override;
  public
    function Filename
                               (      ObjectItem : PLWItem   ) : PChar           ;
    function NumPoints
                               (      ObjectItem : PLWItem   ) : Integer         ;
    function NumPolygons
                               (      ObjectItem : PLWItem   ) : Integer         ;
    function ShadowOpts
                               (      ObjectItem : PLWItem   ) : UInt32          ;
    function Dissolve
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ) : Double          ;
    function MeshInfo
                               (      ObjectItem : PLWItem   ;
                                      FrozenFlag : Integer   ) : PLWMeshInfo     ;
    function Flags
                               (      ObjectItem : PLWItem   ) : UInt32          ;
    function Fog
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ) : Double          ;
    function DispMap
                               (      ObjectItem : PLWItem   ) : PLWTexture      ;
    function ClipMap
                               (      ObjectItem : PLWItem   ) : PLWTexture      ;
    procedure PatchLevel
                               (      ObjectItem : PLWItem   ;
                                      ForDisplay : PInteger  ;
                                      ForRender  : PInteger  ) ;
    procedure MetaballRes
                               (      ObjectItem : PLWItem   ;
                                      ForDisplay : PDouble   ;
                                      ForRender  : PDouble   ) ;
    function BoneSource
                               (      ObjectItem : PLWItem   ) : PLWItem         ;
    function MorphTarget
                               (      ObjectItem : PLWItem   ) : PLWItem         ;
    function MorphAmount
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ) : Double          ;
    function EdgeOpts
                               (      ObjectItem : PLWItem   ) : UInt32          ;
    procedure EdgeColor
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ;
                                      Color      : TLWDVector) ;
    function SubdivOrder
                               (      ObjectItem : PLWItem   ) : Integer         ;
    function PolygonSize
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ) : Double          ;
    function Excluded
                               (      ObjectItem : PLWItem   ;
                                      LightItem  : PLWItem   ) : Integer         ;
    procedure MatteColor
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ;
                                      Color      : TLWDVector) ;
    function Thickness
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ;
                                      Type_      : Integer   ) : Double          ;
    function EdgeZScale
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ) : Double          ;
      // added for version 5: obtains nominal distance value used when shrink edges is enabled.
    function ShrinkEdgesNominalDistance
                               (      ObjectItem : PLWItem   ;
                                      InTime     : TLWTime   ) : Double          ;
      // added for version 6
    function MaxDissolveDistance
                               (      ObjectItem : PLWItem   ) : Double          ;
      // added for version 6
    function BumpDistance
                               (      ObjectItem : PLWItem   ) : Double          ;
      // added for version 7
    function GetGroupIndex
                               (      ObjectItem : PLWItem   ) : UInt32          ;
    function DispMapOrder
                               (      ObjectItem : PLWItem   ) : Integer         ;
    function BumpOrder
                               (      ObjectItem : PLWItem   ) : Integer         ;
    function GetNodeEditor
                               (      ObjectItem : PLWItem   ) : PNodeEditor     ;
    function NodeOrder
                               (      ObjectItem : PLWItem   ) : Integer         ;
      // added for version 8
    procedure Bounds
                               (      ObjectItem : PLWItem   ;
                                      Min        : TLWDVector;
                                      Max        : TLWDVector) ;
    function ShadowOffsetDistance
                               (      ObjectItem : PLWItem   ) : Double          ;
      // added for version 9
    function Instancer
                               (      ObjectItem : PLWItem   ) : PLWItemInstancer;
  end;

  { TBoneInfo }

  TBoneInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    function  Flags
              (      Bone       : PLWItem      ) : UInt32  ;
    procedure RestParam
              (      Bone       : PLWItem      ;
                     ItemParam  : TLWItemParam ;
                     Vector     : TLWDVector   ) ;
    function  RestLength
              (      Bone       : PLWItem      ) : Double  ;
    procedure Limits
              (      Bone       : PLWItem      ;
                     Inner                     ,
                     Outer      : PDouble      ) ;
    function  WeightMap
              (      Bone       : PLWItem      ) : PChar   ; // const
    function  Strength
              (      Bone       : PLWItem      ) : Double  ;
    function  Falloff
              (      Bone       : PLWItem      ) : Integer ;
    procedure JointComp
              (      Bone       : PLWItem      ;
                     Self_                      ,
                     Parent     : PDouble      ) ;
    procedure MuscleFlex
              (      Bone       : PLWItem      ;
                     Self_                     ,
                     Parent     : PDouble      ) ;
    function  Type_
              (      Bone       : PLWItem      ) : Integer ;
    function  Twist
              (      Bone       : PLWItem      ) : Double  ;
    function  Transform
              (      Bone       : PLWItem      ;
                     Transform                 ,
                     RelativeTo : Integer      ;
                     M          : TLWFMatrix3  ;
                     Pos                       ,
                     End_       : TLWFVector   ) : Integer ;
    procedure MuscleBulge
              (      Bone       : PLWItem      ;
                     Self_                     ,
                     Parent     : PDouble      ) ;
    procedure MuscleBulgeMap
              (      Bone       : PLWItem      ;
                     Self_                      ,
                     Parent     : PLWTexture   ) ;
    procedure DisplacementMap
              (      Bone       : PLWItem      ;
                     Self_                     ,
                     Parent     : PLWTexture   ) ;
  end;

  { TLightInfo }

  TLightInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    procedure Ambient
              (      Time       : TLWTime      ;
                     Color      : TLWDVector   );
    function  Type_
              (      ItemID     : PLWItem      ) : Integer    ;
    procedure Color
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ;
                     Color      : TLWDVector   ) ;
    function  ShadowType
              (      ItemID     : PLWItem      ) : Integer    ;
    procedure ConeAngles
              (      ItemID     : PLWItem      ;
                     Radius                    ,
                     Edge       : PDouble      ) ;
    function  Flags
              (      ItemID     : PLWItem      ) : UInt32     ;

    function  Range
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ) : Double     ;
    function  Falloff
              (      ItemID     : PLWItem      ) : Integer     ;
    function  ProjImage
              (      ItemID     : PLWItem      ) : PLWImage    ;
    function  ShadMapSize
              (      ItemID     : PLWItem      ) : Integer     ;
    function  ShadMapAngle
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ) : Double     ;
    function  ShadMapFuzz
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ) : Double     ;
    function  Quality
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ) : Integer    ;
    procedure RawColor
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ;
                     Color      : TLWDVector   ) ;
    function  Intensity
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ) : Double     ;
    procedure ShadowColor
              (      ItemID     : PLWItem      ;
                     Time       : TLWTime      ;
                     Color      : TLWDVector   ) ;
    function  AmbientIntensity
              (      Time       : TLWTime      ) : Double     ;
    procedure AmbientRaw
              (      Time       : TLWTime      ;
                     Color      : TLWDVector   ) ;
  end;


  { TCameraInfo }

  TCameraInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    function  ZoomFactor
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    function  FocalLength
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    function  FocalDistance
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    function  FStop
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    function  BlurLength
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    procedure FovAngles
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ;
                      Horizontal               ,
                      Vertical   : PDouble     )           ;
    function  Flags
              (       ItemID     : PLWItem     ) : UInt32  ;
    procedure Resolution
              (       ItemID     : PLWItem     ;
                      Width                    ,
                      Height     : PInteger    )           ;
    function  PixelAspect
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    function  Separation
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double  ;
    procedure RegionLimits
              (       ItemID     : PLWItem     ;
                      Out_x0                   ,
                      Out_y0                   ,
                      Out_x1                   ,
                      Out_y1     : PInteger    ) ;

        { Defunct}
    procedure MaskLimits
              (       ItemID     : PLWItem     ;
                      Out_x0                   ,
                      Out_y0                   ,
                      Out_x1                   ,
                      Out_y1     : PInteger    ) ;
        { Defunct}
    procedure MaskColor
              (       ItemID     : PLWItem     ;
                      Color      : TLWDVector  ) ;

        { Added for version 3:
          Retrieve motion blur setting for a camera item, 1=normal, 2=dither }
    function  MotionBlur
              (       ItemID     : PLWItem     ) : UInt32  ;
        { Added for version 3:
          Retrieve field rendering state }
    function  FieldRendering
              (       ItemID     : PLWItem     ) : UInt32  ;
    function  IrisPos
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ;
                      Pass       : Integer     ;
                      IX                       ,
                      IY         : PSingle     ) : Integer ;

        { Defunct}
    function  UsingGlobalResolution
              (       ItemID     : PLWItem     ) : Integer ;
        { Defunct}
    function  UsingGlobalBlur
              (       ItemID     : PLWItem     ) : Integer ;
        { Defunct}
    function  UsingGlobalMask
              (       ItemID     : PLWItem     ) : Integer ;
    function  MotionBlurPasses
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : UInt32 ;
    function  ShutterEfficiency
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double ;
    function  NoiseSampler
              (       ItemID     : PLWItem     ) : UINt32  ;
    procedure FilmSize
              (        ItemID    : PLWItem     ;
                       Width                   ,
                       Height    : PDouble     ) ;
    function  FrameTiming
              (       ItemID     : PLWItem     ;
                      Frame      : TLWFrame    ;
                      TimingInfo : PLWFrameTimingInfo ) : UInt32 ;
    function  AntiAliasing
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : UInt32 ;
    function  OverSampling
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double ;
    procedure Diaphragm
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ;
                      Sides      : PInteger    ;
                      Rotation   : PDouble     ) ;
    function  ConvergencePoInteger
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double ;
    function  UsingConvergencePoInteger
              (       ItemID     : PLWItem     ) : Integer ;
    function  ConvergenceToeIn
              (       ItemID     : PLWItem     ;
                      Time       : TLWTime     ) : Double ;
  end;

  { TSceneInfo }

  TSceneInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
        Name               : PChar    ; // const
    Filename           : PChar    ; // const
    NumPoints                     ,
    NumPolygons                   ,
    RenderType                    ,
    RenderOpts         : Integer  ;
    FrameStart         : TLWFrame ;
    FrameEnd           : TLWFrame ;
    FrameStep          : TLWFrame ;
    FramesPerSecond    : Double   ;
    FrameWidth                    ,
    FrameHeight        : Integer  ;
    PixelAspect        : Double   ;
    MinSamplesPerPixel            ,
    MaxSamplesPerPixel : Integer  ;
    LimitedRegion      : Array[0..3] of Integer; { x0, y0, x1, y1}
    RecursionDepth     : Integer  ;
    RenderCamera       : function
                         (       Time   : TLWTime ) : PLWItem ;
    NumThreads         : Integer  ;
    AnimFilename       : Pchar    ; // const
    RGBPrefix          : Pchar    ; // const
    AlphaPrefix        : Pchar    ; // const
    { Added for version 4:
        Current antialiasing setting 0=off, 1-lowest,
        increasing for higher values (currently up to 4=extreme)
      Added 12/29/2004  :
        100 to 114; use PLD (with level 1 being 100 and level 15 being 114) }
    Antialiasing       : Integer  ;
    { Added for version 4:
        1=enabled, 0=disabled. Only valid when antialiasing is 1 thru 4 }
    EnhancedAA         : Integer  ;
    { Added for version 4:
        1=enabled, 0=disabled }
    AdaptiveSampling   : Integer  ;
    { Added for version 4:
        Only valid when adaptiveSampling is enabled }
    AdaptiveThreshold  : Single   ;
    { Added for version 4:
        bit 0: 1=soft filter, 0=no filter
      Added 12/29/2004:
        bits 1thru5 indicate reconstruction filter.
              1-3   = box(std,sharp,soft)     ;
              4-6   = Gaussian(std,sharp,soft);
              7-9   = Mitchell(std,sharp,soft);
              10-12 = Lanczos(std,sharp,soft) ; }
    Filter             : Integer  ;
    DblSidedAreaLights : Integer  ;
    { Added for version 5:
        0 = no scene loading;
        1 = scene load is in progress;
        2 = load-from-scene in progress }
    LoadInProgress               : Integer  ;
    RadiosityType                : Integer  ;
    RadiosityIndirectBounceCount : Integer  ;
    RadiosityRaysPerEvaluation1  : Integer  ;
    RadiosityRaysPerEvaluation2  : Integer  ;
    RadiosityIntensity                      ,
    RadiosityAngularTolerance               ,
    RadiosityMinimumPixelSpacing            ,
    RadiosityMaximumPixelSpacing            ,
    RadiosityMultiplier          : Double   ;
    RadiosityFileName            : Pchar    ; // const
    { Added for LW9.6 }
    CausticsIntensity            : Double   ;
    CausticsAccuracy                        ,
    CausticsSoftness                        ,
    RadiosityFlags               : Integer  ;
    DynamicsRangeMin                        ,
    DynamicsRangeMax                        ,
    Saturation                   : Double   ;

    PixelFilterForceMT                      ,
    { All active pixel filters are capable of multi-threading. }
    HasMultithreadedFilters                 ,
    UseZminmax                   : Integer  ;
    Zmin                                    ,
    Zmax                         : Double   ;
    { LWRENDERINGMODE enum.}
    Rendermode                              ,
    { Forces the calculation of normals, in layout or while rendering. }
    CalculateAllNormals          : Integer  ;
    { Added for LW9.7 }
    EnableLenseFlares            : Integer  ;
    LenseFlareIntensity          : Double   ;
    { Added for LW10.1 *}
    { Pointer to the flags array of the buffers currently in use. }
    BuffersInUse                 : PInteger ;
    { Current phase of animation calculation (LWANIMPASS_). }
    AnimationPass                : Integer  ;

    { Added for LW11 }
    RayCutoff                    : Single   ;
    Shadingsamples                          ,
    Lightsamples                 : UInt32   ;
  end;

  { TTimeInfo }

  TTimeInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    Time    : TLWTime  ;
    Frame   : TLWFrame ;
  end;

  { TCompInfo }

  TCompInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    BG         ,
    FG         ,
    FGAlpha    : PLWImage;
  end;

  { TBackdropInfo }

  TBackdropInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    procedure Backdrop
               (      Time   : TLWTime               ;
                const Ray    : array {[0..2]} of Double ;
                      Color  : array {[0..2]} of Double ) ;
  public
    Type_    : Integer                               ;
    procedure Color
               (      Time   : TLWTime               ;
                      Zenith                         ,
                      Sky                            ,
                      Ground                         ,
                      Nadir  : array {[0..2]} of Double ) ;
    procedure Squeeze
               (      Time   : TLWTime               ;
                      Sky                            ,
                      Ground : PDouble               );
  end;

  { TFogInfo }

  TFogInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    Type_   : Integer      ;
    Flags   : UInt32       ;
    function  MinDist
               (      Time   : TLWTime                  ) : Double;
    function  MaxDist
               (      Time   : TLWTime                  ) : Double;
    function  MinAmt
               (      Time   : TLWTime                  ) : Double;
    function  MaxAmt
               (      Time   : TLWTime                  ) : Double;
    procedure Color
              (      Time   : TLWTime                  ;
                     Col    : array {[0..2]} of Double ) ;
  end;

  { TInterfaceInfo }

   TInterfaceInfo = class(TGlobal)
   protected
     function GetGlobalType : String; override;
   public
     CurTime              : TLWTime ;
     SelItems             : PLWItem ;

     function  ItemFlags
                            (      Item  : PLWItem    ) : Uint32 ;
   public
     PreviewStart         ,
     PreviewEnd           ,
     PreviewStep          : TLWFrame;

     DynaUpdate           : Integer ;

     procedure SchemaPos
                            (      Item  : PLWItem    ;
                                   X     ,
                                   Y     : PDouble    ) ;
     function ItemVis
                            (      Item  : PLWItem    ) : Integer;
   public
     DisplayFlags         ,
     GeneralFlags         : Uint32  ;
     BoxThreshold         : Integer ;

     function  ItemColor
                            (      Item  : PLWItem    ) : Integer;
     procedure SetItemColorIndex
                            (      Item  : PLWItem    ;
                                   Color : Integer    ) ;
     procedure SetItemColorCustom
                            (      Item  : PLWItem    ;
                                   Color : PDouble    ) ;
    public
     AlertLevel                     ,
     AutoKeyCreate        : Integer ;

     procedure DefaultItemTypeColor
                            (      Item  : PLWItem    ;
                                   Color : PSingle    ;
                                   Set_  : Integer    ) ;
     procedure ItemColorRGBA
                            (      Item  : PLWItem    ;
                                   State : UInt32     ;
                                   RGBA  : TLWFVector4) ;
     function  ItemIconScale
                            (      Item  : PLWItem    ) : Single ;
   end;

  { TViewportInfo }

  TViewportInfo = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
    NumViewports : Integer;
    function  Type_
                   (      Index         : Integer                 ) : Integer;
    function  Flags
                   (      Index         : Integer                 ) : UInt32 ;
    procedure Pos
                   (      Index         : Integer                 ;
                          Spot          : TLWDVector              ) ;
    procedure Xfrm
                   (      Index         : Integer                 ;
                          Mat           : Array {[0..8]} of Double) ;
    procedure Clip
                   (      Index         : Integer                 ;
                          Hither        ,
                          Yon           : PDouble                 ) ;
    procedure Rect
                   (      Index         : Integer                 ;
                          Left, Top     ,
                          Width, Height : PInteger                ) ;
    function  ViewLevel
                   (      Index         : Integer                 ) : Integer;
    function  Projection
                   (      Index         : Integer                 ;
                          Projection    ,
                          InvProjection : TLWDMatrix4             ) : Integer;
    function  Modelview
                   (      Index         : Integer                 ;
                          Modelview     ,
                          InvModelView  : TLWDMatrix4             ) : Integer;
    function  Project
                   (      Index         : Integer                 ;
                          World         : TLWDVector              ;
                          WinX          ,
                          WinY          ,
                          WinZ          : PDouble                 ) : Integer;
    function  UnProject
                   (      Index         : Integer                 ;
                          WinX          ,
                          WinY          ,
                          WinZ          : Double                  ;
                          World         : TLWDVector              ) : Integer;
    function PixelSize
             (      Index  : Integer        ;
                    Pixels : Double         ;
                    RefPos : array of Double) : Double ;
    function HandleSize
             (      Index  : Integer        ) : Integer;
    function  GridSize
                   (      Index         : Integer                 ) : Double ;
    function  ViewItem
                   (      Index         : Integer                 ) : PLWItem;
    function  GridType
                   (      Index         : Integer                 ) : Integer;
  end;

  { TGlobalPool }

  TGlobalPool = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
   function First
               ( const Void                   ) : PLWMemChunk ;
   function Next
               (       MemChunk : PLWMemChunk ) : PLWMemChunk ;
   function ID
               (       MemChunk : PLWMemChunk ) : PChar       ; // const
   function Size
               (       MemChunk : PLWMemChunk ) : Integer     ;
   function Find
               ( const InID     : PChar       ) : PLWMemChunk ;
   function Create
               ( const InID     : PChar       ;
                       InSize   : Integer     ) : PLWMemChunk ;
  end;

  { TGlobalRenderPool }

  TGlobalRenderPool = class(TGlobal)
  protected
    function GetGlobalType                    : String ; override;
  public
   function First
               ( const Void                   ) : PLWMemChunk ;
   function Next
               (       MemChunk : PLWMemChunk ) : PLWMemChunk ;
   function ID
               (       MemChunk : PLWMemChunk ) : PChar       ; // const
   function Size
               (       MemChunk : PLWMemChunk ) : Integer     ;
   function Find
               ( const InID     : PChar       ) : PLWMemChunk ;
   function Create
               ( const InID     : PChar       ;
                       InSize   : Integer     ) : PLWMemChunk ;
  end;

implementation

{ TListInfo }

function TListInfo.GetGlobalType: String;
begin
  Result := LWLISTINFO_GLOBAL;
end;

function TListInfo.Index
                   (    Object_: PLWItem ) : Integer;
begin
  Result := PLWListInfo(FGlobal).Index(Object_);
end;

function TListInfo.Reorder
                   (      List: PPLWItem ) : Integer;
begin
  Result := PLWListInfo(FGlobal).Reorder(List);
end;

function TListInfo.Swap
                   (   List: PPLWItem ) : Integer;
begin
  Result := PLWListInfo(FGlobal).Swap(List);
end;

function TListInfo.Splice
                   (     Point : PLWItem ;
                         List  : PPLWItem ) : Integer;
begin
  Result := PLWListInfo(FGlobal).Splice(Point, List);
end;

{ TItemInfo }

function  TItemInfo.GetGlobalType                  : String;
begin
  Result := LWITEMINFO_GLOBAL;
end;

function TItemInfo.First
                   (    Itemtype   : TLWItemType ;
                        BoneObject : PLWItem     ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).First(Itemtype, BoneObject);
end;

function TItemInfo.Next
                   (   Item  : PLWItem ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).Next(Item);
end;

function TItemInfo.FirstChild
                   (         Parent : PLWItem ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).FirstChild(Parent);
end;

function TItemInfo.NextChild
                   (        Parent    : PLWItem ;
                            PrevChild : PLWItem ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).NextChild(Parent, PrevChild);
end;

function TItemInfo.Parent
                   (   Item  : PLWItem ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).Parent(Item);
end;

function TItemInfo.Target
                   (   Item  : PLWItem ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).Target(Item);
end;

function TItemInfo.Goal
                   (   Item  : PLWItem ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).Goal(Item);
end;

function TItemInfo.Type_(Item: PLWItem): TLWItemType;
begin
  Result := PLWItemInfo(FGlobal).Type_(Item);
end;

function TItemInfo.Name(Item: PLWItem): PChar;
begin
  Result := PLWItemInfo(FGlobal).Name(Item);
end;

procedure TItemInfo.Param
                    (      Item      : PLWItem   ;
                           ParamType : TItemParam;
                           Time      : TLWTime   ;
                       var Vector    : TLWDVector) ;
begin
  PLWItemInfo(FGlobal).Param(Item, Integer(ParamType), Time, Vector);
end;

function TItemInfo.Limits
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ;
                           Min       : TLWDVector   ;
                           Max       : TLWDVector   ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).Limits(Item, Integer(ParamType), Min, Max);
end;

function TItemInfo.GetTag
                   (       Item      : PLWItem      ;
                           TagNum    : Integer      ) : PChar;
begin
  Result := PLWItemInfo(FGlobal).GetTag(Item, TagNum);
end;

procedure TItemInfo.SetTag
                    (      Item        : PLWItem    ;
                           TagNum      : Integer    ;
                           Tag         : PChar      ) ;
begin
  PLWItemInfo(FGlobal).SetTag(Item, TagNum, Tag);
end;

function TItemInfo.ChanGroup
                   (       Item      : PLWItem      ) : PLWChanGroup;
begin
  Result := PLWItemInfo(FGlobal).ChanGroup(Item);
end;

function TItemInfo.Server
                   (       Item      : PLWItem      ;
                           Class_    : PChar        ;
                           Index     : Integer      ) : PChar;
begin
  Result := PLWItemInfo(FGlobal).Server(Item, Class_, Index );
end;

function TItemInfo.ServerFlags
                   (       Item      : PLWItem      ;
                           Class_    : PChar        ;
                           Index     : Integer      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).ServerFlags(Item, Class_, Index );
end;

procedure TItemInfo.Controller
                    (      Item      : PLWItem      ;
                           ParamType : TLWItemParam ;
                           Type_     : array of Integer ) ;
begin
  PLWItemInfo(FGlobal).Controller(Item, Integer(ParamType), Type_);
end;

function TItemInfo.Flags
                   (       Item      : PLWItem      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).Flags(Item);
end;

function TItemInfo.LookAhead
                   (       Item      : PLWItem      ) : TLWTime;
begin
  Result := PLWItemInfo(FGlobal).LookAhead(Item);
end;

function TItemInfo.GoalStrength
                   (       Item      : PLWItem      ;
                           Time      : TLWTime      ) : Double;
begin
  Result := PLWItemInfo(FGlobal).GoalStrength(Item, Time);
end;

procedure TItemInfo.Stiffness
                    (      Item      : PLWItem      ;
                           ParamType : TLWItemParam ;
                           Vector    : TLWDVector   ) ;
begin
  PLWItemInfo(FGlobal).Stiffness(Item, Integer(ParamType), Vector);
end;

function TItemInfo.AxisLocks
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).AxisLocks(Item, Integer(ParamType));
end;

function TItemInfo.MaxLookSteps
                   (       Item      : PLWItem      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).MaxLookSteps(Item);
end;

function TItemInfo.ReliableDistance
                   (       Item      : PLWItem      ) :  Double;
begin
  Result := PLWItemInfo(FGlobal).ReliableDistance(Item);
end;

function TItemInfo.GoalObjective
                   (       Item      : PLWItem      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).GoalObjective(Item);
end;

function TItemInfo.IKFKBlending
                   (       Item      : PLWItem      ;
                           Time      : TLWTime      ) : Double;
begin
  Result := PLWItemInfo(FGlobal).IKFKBlending(Item, Time);
end;

function TItemInfo.IKInitialState
                   (       Item      : PLWItem      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).IKInitialState(Item);
end;

function TItemInfo.IKInitialStateFrame
                   (       Item      : PLWItem      ;
                           Time      : TLWTime      ) : TLWFrame;
begin
  Result := PLWItemInfo(FGlobal).IKInitialStateFrame(Item, Time);
end;

function TItemInfo.IKSoft
                   (       Item         : PLWItem      ;
                           Time         : TLWTime      ;
                           DistanceType : PUInt32      ;
                           Min          : PDouble      ;
                           Max          : PDouble      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).IKSoft(Item, Time, DistanceType, Min, Max);
end;

function TItemInfo.Pole
                   (       Item      : PLWItem      ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).Pole(Item);
end;

function TItemInfo.SameItem
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ) : PLWItem;
begin
  Result := PLWItemInfo(FGlobal).SameItem(Item, Integer(ParamType));
end;

function TItemInfo.SameItemBlend
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ;
                           Time      : TLWTime      ) : Double;
begin
  Result := PLWItemInfo(FGlobal).SameItemBlend(Item, Integer(ParamType), Time);
end;

function TItemInfo.SameItemBlendMethod
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).SameItemBlendMethod(Item, Integer(ParamType));
end;

function TItemInfo.SameItemFlags
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).SameItemFlags(Item, Integer(ParamType));
end;

function TItemInfo.Selected
                   (       Item      : PLWItem      ) : UInt32;
begin
  Result := PLWItemInfo(FGlobal).Selected(Item);
end;

procedure TItemInfo.Follow
                   (       Item      : PLWItem      ;
                           ParamType : TLWItemParam ;
                           Follow    : array of Integer;
                           Txtr      : array of PLWTexture ) ;
begin
  PLWItemInfo(FGlobal).Follow(Item, Integer(ParamType), Follow, Txtr);
end;

procedure TItemInfo.ControllerTrans
                   (       Item      : PLWItem         ;
                           ParamType : TLWItemParam    ;
                           Mul       : array of Double ;
                           Add       : array of Double     ) ;
begin
  PLWItemInfo(FGlobal).ControllerTrans(Item, Integer(ParamType), Mul, Add);
end;

{ TObjectInfo }

function TObjectInfo.GetGlobalType: String;
begin
  Result := LWOBJECTINFO_GLOBAL;
end;

function TObjectInfo.Filename
                     (       ObjectItem : PLWItem ) : PChar;
begin
  Result := PLWObjectInfo(FGlobal).Filename(ObjectItem);
end;

function TObjectInfo.NumPoints
                     (       ObjectItem : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).NumPoints(ObjectItem);
end;

function TObjectInfo.NumPolygons
                     (       ObjectItem : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).NumPolygons(ObjectItem);
end;

function TObjectInfo.ShadowOpts
                     (       ObjectItem : PLWItem ) : UInt32;
begin
  Result := PLWObjectInfo(FGlobal).ShadowOpts(ObjectItem);
end;

function TObjectInfo.Dissolve
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).Dissolve(ObjectItem, InTime);
end;

function TObjectInfo.MeshInfo
                     (       ObjectItem : PLWItem ;
                             FrozenFlag : Integer ) : PLWMeshInfo;
begin
  Result := PLWObjectInfo(FGlobal).MeshInfo(ObjectItem, FrozenFlag);
end;

function TObjectInfo.Flags
                     (       ObjectItem : PLWItem ) : UInt32;
begin
  Result := PLWObjectInfo(FGlobal).Flags(ObjectItem);
end;

function TObjectInfo.Fog
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).Fog(ObjectItem, InTime);
end;

function TObjectInfo.DispMap
                     (       ObjectItem : PLWItem ) : PLWTexture;
begin
  Result := PLWObjectInfo(FGlobal).DispMap(ObjectItem);
end;

function TObjectInfo.ClipMap
                     (       ObjectItem : PLWItem ) : PLWTexture;
begin
  Result := PLWObjectInfo(FGlobal).ClipMap(ObjectItem);
end;

procedure TObjectInfo.PatchLevel
                      (         ObjectItem : PLWItem  ;
                                ForDisplay : PInteger ;
                                ForRender  : PInteger ) ;
begin
  PLWObjectInfo(FGlobal).PatchLevel(ObjectItem, ForDisplay, ForRender);
end;

procedure TObjectInfo.MetaballRes
                     (       ObjectItem : PLWItem ;
                             ForDisplay : PDouble ;
                             ForRender  : PDouble ) ;
begin
  PLWObjectInfo(FGlobal).MetaballRes(ObjectItem, ForDisplay, ForRender);
end;

function TObjectInfo.BoneSource
                     (       ObjectItem : PLWItem ) : PLWItem;
begin
  Result := PLWObjectInfo(FGlobal).BoneSource(ObjectItem);
end;

function TObjectInfo.MorphTarget
                     (       ObjectItem : PLWItem ) : PLWItem;
begin
  Result := PLWObjectInfo(FGlobal).MorphTarget(ObjectItem);
end;

function TObjectInfo.MorphAmount
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).MorphAmount(ObjectItem, InTime);
end;

function TObjectInfo.EdgeOpts
                     (       ObjectItem : PLWItem ) : UInt32;
begin
  Result := PLWObjectInfo(FGlobal).EdgeOpts(ObjectItem);
end;

procedure TObjectInfo.EdgeColor
                      (        ObjectItem : PLWItem    ;
                               InTime     : TLWTime    ;
                               Color      : TLWDVector ) ;
begin
  TObjectInfo(FGlobal).EdgeColor(ObjectItem, InTime, Color);
end;

function TObjectInfo.SubdivOrder
                     (       ObjectItem : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).SubdivOrder(ObjectItem);
end;

function TObjectInfo.PolygonSize
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).PolygonSize(ObjectItem, InTime);
end;

function TObjectInfo.Excluded
                     (       ObjectItem : PLWItem ;
                             LightItem  : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).Excluded(ObjectItem, LightItem);
end;

procedure TObjectInfo.MatteColor
                      (        ObjectItem : PLWItem    ;
                               InTime     : TLWTime    ;
                               Color      : TLWDVector ) ;
begin
  PLWObjectInfo(FGlobal).MatteColor(ObjectItem, InTime, Color);
end;

function TObjectInfo.Thickness
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ;
                             Type_      : Integer ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).Thickness(ObjectItem, InTime, Type_);
end;

function TObjectInfo.EdgeZScale
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).EdgeZScale(ObjectItem, InTime);
end;

function TObjectInfo.ShrinkEdgesNominalDistance
                     (       ObjectItem : PLWItem ;
                             InTime     : TLWTime ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).ShrinkEdgesNominalDistance(ObjectItem, InTime);
end;

function TObjectInfo.MaxDissolveDistance
                     (       ObjectItem : PLWItem ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).MaxDissolveDistance(ObjectItem);
end;

function TObjectInfo.BumpDistance
                     (       ObjectItem : PLWItem ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).BumpDistance(ObjectItem);
end;

function TObjectInfo.GetGroupIndex
                     (       ObjectItem : PLWItem ) : UInt32;
begin
  Result := PLWObjectInfo(FGlobal).GetGroupIndex(ObjectItem);
end;

function TObjectInfo.DispMapOrder
                     (       ObjectItem : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).DispMapOrder(ObjectItem);
end;

function TObjectInfo.BumpOrder
                     (       ObjectItem : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).BumpOrder(ObjectItem);
end;

function TObjectInfo.GetNodeEditor
                     (       ObjectItem : PLWItem ) : PNodeEditor;
begin
  Result := PLWObjectInfo(FGlobal).GetNodeEditor(ObjectItem);
end;

function TObjectInfo.NodeOrder
                     (       ObjectItem : PLWItem ) : Integer;
begin
  Result := PLWObjectInfo(FGlobal).NodeOrder(ObjectItem);
end;

procedure TObjectInfo.Bounds
                      (     ObjectItem : PLWItem    ;
                            Min        : TLWDVector ;
                            Max        : TLWDVector ) ;
begin
  PLWObjectInfo(FGlobal).Bounds(ObjectItem, Min, Max);
end;

function TObjectInfo.ShadowOffsetDistance
                     (       ObjectItem : PLWItem ) : Double;
begin
  Result := PLWObjectInfo(FGlobal).ShadowOffsetDistance(ObjectItem);
end;

function TObjectInfo.Instancer
                     (       ObjectItem : PLWItem ) : PLWItemInstancer;
begin
  Result := PLWObjectInfo(FGlobal).Instancer(ObjectItem);
end;

{ TBoneInfo }

function TBoneInfo.GetGlobalType: String;
begin
  Result := LWBONEINFO_GLOBAL ;
end;

function TBoneInfo.Flags
                   (    Bone      : PLWItem ) : UInt32;
begin
  Result := PLWBoneInfo(FGlobal).Flags(Bone);
end;

procedure TBoneInfo.RestParam
                    (   Bone      : PLWItem      ;
                        ItemParam : TLWItemParam ;
                        Vector    : TLWDVector   ) ;
begin
  PLWBoneInfo(FGlobal).RestParam(Bone, ItemParam, Vector);
end;

function TBoneInfo.RestLength
                   (    Bone      : PLWItem ) : Double;
begin
  Result := PLWBoneInfo(FGlobal).RestLength(Bone);
end;

procedure TBoneInfo.Limits
                   (    Bone      : PLWItem ;
                        Inner     ,
                        Outer     : PDouble ) ;
begin
  PLWBoneInfo(FGlobal).Limits(Bone, Inner, Outer);
end;

function TBoneInfo.WeightMap
                   (    Bone      : PLWItem ) : PChar;
begin
  Result := PLWBoneInfo(FGlobal).WeightMap(Bone);
end;

function TBoneInfo.Strength
                   (    Bone      : PLWItem ) : Double;
begin
  Result := PLWBoneInfo(FGlobal).Strength(Bone);
end;

function TBoneInfo.Falloff
                   (    Bone      : PLWItem ) : Integer;
begin
  Result := PLWBoneInfo(FGlobal).Falloff(Bone);
end;

procedure TBoneInfo.JointComp
                   (    Bone      : PLWItem ;
                        Self_     ,
                        Parent    : PDouble ) ;
begin
  PLWBoneInfo(FGlobal).JointComp(Bone, Self_, Parent);
end;

procedure TBoneInfo.MuscleFlex
                   (    Bone      : PLWItem ;
                        Self_     ,
                        Parent    : PDouble ) ;
begin
  PLWBoneInfo(FGlobal).MuscleFlex(Bone, Self_, Parent);
end;

function TBoneInfo.Type_
                   (    Bone      : PLWItem ) : Integer;
begin
  Result := PLWBoneInfo(FGlobal).Type_(Bone);
end;

function TBoneInfo.Twist
                   (    Bone      : PLWItem ) : Double;
begin
  Result := PLWBoneInfo(FGlobal).Twist(Bone);
end;

function TBoneInfo.Transform
                   (    Bone      : PLWItem     ;
                        Transform ,
                        RelativeTo: Integer     ;
                        M         : TLWFMatrix3 ;
                        Pos       ,
                        End_      : TLWFVector ) : Integer;
begin
  Result := PLWBoneInfo(FGlobal).Transform(Bone, Transform, RelativeTo, M, Pos, End_);
end;

procedure TBoneInfo.MuscleBulge
                   (    Bone      : PLWItem ;
                        Self_     ,
                        Parent    : PDouble ) ;
begin
  PLWBoneInfo(FGlobal).MuscleBulge(Bone, Self_, Parent);
end;

procedure TBoneInfo.MuscleBulgeMap
                   (    Bone      : PLWItem ;
                        Self_     ,
                        Parent    : PLWTexture ) ;
begin
  PLWBoneInfo(FGlobal).MuscleBulgeMap(Bone, Self_, Parent);
end;

procedure TBoneInfo.DisplacementMap
                   (    Bone      : PLWItem ;
                        Self_     ,
                        Parent    : PLWTexture ) ;
begin
  PLWBoneInfo(FGlobal).DisplacementMap(Bone, Self_, Parent);
end;

{ TLightInfo }

function TLightInfo.GetGlobalType: String;
begin
  Result := LWLIGHTINFO_GLOBAL ;
end;

procedure TLightInfo.Ambient
                     (      Time       : TLWTime      ;
                            Color      : TLWDVector   ) ;
begin
  PLWLightInfo(FGlobal).Ambient(Time, Color);
end;

function TLightInfo.Type_
                    (       ItemID     : PLWItem      ) : Integer;
begin
  Result := PLWLightInfo(FGlobal).Type_(ItemID);
end;

procedure TLightInfo.Color
                     (      ItemID     : PLWItem      ;
                            Time       : TLWTime      ;
                            Color      : TLWDVector)  ;
begin
  PLWLightInfo(FGlobal).Color(ItemID, Time, Color);
end;

function TLightInfo.ShadowType
                    (       ItemID     : PLWItem      ) : Integer;
begin
  Result := PLWLightInfo(FGlobal).ShadowType(ItemID);
end;

procedure TLightInfo.ConeAngles
                    (       ItemID     : PLWItem      ;
                            Radius     ,
                            Edge       : PDouble      ) ;
begin
  PLWLightInfo(FGlobal).ConeAngles(ItemID, Radius, Edge);
end;

function TLightInfo.Flags
                    (       ItemID     : PLWItem      ): UInt32;
begin
  Result := PLWLightInfo(FGlobal).Flags(ItemID);
end;

function TLightInfo.Range
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ) : Double;
begin
  Result := PLWLightInfo(FGlobal).Range(ItemID, Time);
end;

function TLightInfo.Falloff
                    (       ItemID     : PLWItem      ) : Integer;
begin
  Result := PLWLightInfo(FGlobal).Falloff(ItemID);
end;

function TLightInfo.ProjImage
                    (       ItemID     : PLWItem      ) : PLWImage;
begin
  Result := PLWLightInfo(FGlobal).ProjImage(ItemID);
end;

function TLightInfo.ShadMapSize
                    (       ItemID     : PLWItem      ) : Integer;
begin
  Result := PLWLightInfo(FGlobal).ShadMapSize(ItemID);
end;

function TLightInfo.ShadMapAngle
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ) : Double;
begin
  Result := PLWLightInfo(FGlobal).ShadMapAngle(ItemID, Time);
end;

function TLightInfo.ShadMapFuzz
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ) : Double;
begin
  Result := PLWLightInfo(FGlobal).ShadMapFuzz(ItemID, Time);
end;

function TLightInfo.Quality
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ) : Integer;
begin
  Result := PLWLightInfo(FGlobal).Quality(ItemID, Time);
end;

procedure TLightInfo.RawColor
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ;
                            Color      : TLWDVector   ) ;
begin
  PLWLightInfo(FGlobal).RawColor(ItemID, Time, Color);
end;

function TLightInfo.Intensity
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ) : Double;
begin
  Result := PLWLightInfo(FGlobal).Intensity(ItemID, Time);
end;

procedure TLightInfo.ShadowColor
                    (       ItemID     : PLWItem      ;
                            Time       : TLWTime      ;
                            Color      : TLWDVector   ) ;
begin
  PLWLightInfo(FGlobal).ShadowColor(ItemID, Time, Color);
end;

function TLightInfo.AmbientIntensity
                    (       Time       : TLWTime      ) : Double;
begin
  Result := PLWLightInfo(FGlobal).AmbientIntensity(Time);
end;

procedure TLightInfo.AmbientRaw
                     (      Time       : TLWTime      ;
                            Color      : TLWDVector   ) ;
begin
  PLWLightInfo(FGlobal).AmbientRaw(Time, Color);
end;

{ TCameraInfo }

function TCameraInfo.GetGlobalType: String;
begin
  Result := LWCAMERAINFO_GLOBAL;
end;

function TCameraInfo.ZoomFactor
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).ZoomFactor(ItemID, Time);
end;

function TCameraInfo.FocalLength
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).FocalLength(ItemID, Time);
end;

function TCameraInfo.FocalDistance
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).FocalDistance(ItemID, Time);
end;

function TCameraInfo.FStop
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).FStop(ItemID, Time);
end;

function TCameraInfo.BlurLength
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).BlurLength(ItemID, Time);
end;

procedure TCameraInfo.FovAngles
                      (      ItemID     : PLWItem     ;
                             Time       : TLWTime     ;
                             Horizontal ,
                             Vertical   : PDouble     ) ;
begin
  PLWCameraInfo(FGlobal).FovAngles(ItemID, Time, Horizontal , Vertical);
end;

function TCameraInfo.Flags
                     (       ItemID     : PLWItem     ) : UInt32;
begin
  Result := PLWCameraInfo(FGlobal).Flags(ItemID);
end;

procedure TCameraInfo.Resolution
                      (      ItemID     : PLWItem     ;
                             Width      ,
                             Height     : PInteger    ) ;
begin
  PLWCameraInfo(FGlobal).Resolution(ItemID, Width, Height);
end;

function TCameraInfo.PixelAspect
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).PixelAspect(ItemID, Time);
end;

function TCameraInfo.Separation
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).Separation(ItemID, Time);
end;

procedure TCameraInfo.RegionLimits
                     (       ItemID     : PLWItem     ;
                             Out_x0     ,
                             Out_y0     ,
                             Out_x1     ,
                             Out_y1     : PInteger    ) ;
begin
  PLWCameraInfo(FGlobal).RegionLimits(ItemID, Out_x0, Out_x1, Out_y0, Out_y1);
end;

procedure TCameraInfo.MaskLimits
                     (       ItemID     : PLWItem     ;
                             Out_x0     ,
                             Out_y0     ,
                             Out_x1     ,
                             Out_y1     : PInteger    ) ;
begin
  PLWCameraInfo(FGlobal).MaskLimits(ItemID, Out_x0, Out_x1, Out_y0, Out_y1);
end;

procedure TCameraInfo.MaskColor
                     (       ItemID     : PLWItem     ;
                             Color      : TLWDVector  ) ;
begin
  PLWCameraInfo(FGlobal).MaskColor(ItemID, Color);
end;

function TCameraInfo.MotionBlur
                     (       ItemID     : PLWItem     ) : UInt32;
begin
  Result := PLWCameraInfo(FGlobal).MotionBlur(ItemID);
end;

function TCameraInfo.FieldRendering
                     (       ItemID     : PLWItem     ) : UInt32;
begin
  Result := PLWCameraInfo(FGlobal).FieldRendering(ItemID);
end;

function TCameraInfo.IrisPos
                     (       ItemID     : PLWItem     ;
                             Time       : TLWTime     ;
                             Pass       : Integer     ;
                             IX         ,
                             IY         : PSingle     ) : Integer;
begin
  Result := PLWCameraInfo(FGlobal).IrisPos(ItemID, Time, Pass, IX, IY);
end;

function TCameraInfo.UsingGlobalResolution
                     (       ItemID     : PLWItem     ) : Integer;
begin
  Result := PLWCameraInfo(FGlobal).UsingGlobalResolution(ItemID);
end;

function TCameraInfo.UsingGlobalBlur
                     (       ItemID     : PLWItem     ) : Integer;
begin
  Result := PLWCameraInfo(FGlobal).UsingGlobalBlur(ItemID);
end;

function TCameraInfo.UsingGlobalMask
                     (       ItemID     : PLWItem     ) : Integer;
begin
  Result := PLWCameraInfo(FGlobal).UsingGlobalMask(ItemID);
end;

function TCameraInfo.MotionBlurPasses
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : UInt32;
begin
  Result := PLWCameraInfo(FGlobal).MotionBlurPasses(ItemID, Time);
end;

function TCameraInfo.ShutterEfficiency
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).ShutterEfficiency(ItemID, Time);
end;

function TCameraInfo.NoiseSampler
                     (       ItemID     : PLWItem     ) : UINt32;
begin
  Result := PLWCameraInfo(FGlobal).NoiseSampler(ItemID);
end;

procedure TCameraInfo.FilmSize
                     (       ItemID     : PLWItem     ;
                             Width      ,
                             Height     : PDouble     ) ;
begin
  PLWCameraInfo(FGlobal).FilmSize(ItemID, Width, Height);
end;

function TCameraInfo.FrameTiming
                     (       ItemID     : PLWItem     ;
                             Frame      : TLWFrame    ;
                             TimingInfo : PLWFrameTimingInfo ) : UInt32;
begin
  Result := PLWCameraInfo(FGlobal).FrameTiming(ItemID, Frame, TimingInfo);
end;

function TCameraInfo.AntiAliasing
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : UInt32;
begin
  Result := PLWCameraInfo(FGlobal).AntiAliasing(ItemID, Time);
end;

function TCameraInfo.OverSampling
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).OverSampling(ItemID, Time);
end;

procedure TCameraInfo.Diaphragm
                     (       ItemID     : PLWItem     ;
                             Time       : TLWTime     ;
                             Sides      : PInteger    ;
                             Rotation   : PDouble     ) ;
begin
  PLWCameraInfo(FGlobal).Diaphragm(ItemID, Time, Sides, Rotation);
end;

function TCameraInfo.ConvergencePoInteger
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) :Double;
begin
  Result := PLWCameraInfo(FGlobal).ConvergencePoInteger(ItemID, Time);
end;

function TCameraInfo.UsingConvergencePoInteger
                     (       ItemID     : PLWItem     ) : Integer;
begin
  Result := PLWCameraInfo(FGlobal).UsingConvergencePoInteger(ItemID);
end;

function TCameraInfo.ConvergenceToeIn
                     (       ItemID     : PLWItem     ;
                      Time       : TLWTime            ) : Double;
begin
  Result := PLWCameraInfo(FGlobal).ConvergenceToeIn(ItemID, Time);
end;

{ TSceneInfo }

function TSceneInfo.GetGlobalType: String;
begin
  Result := LWSCENEINFO_GLOBAL ;
end;

{ TTimeInfo }

function TTimeInfo.GetGlobalType: String;
begin
  Result := LWTIMEINFO_GLOBAL ;
end;

{ TCompInfo }

function TCompInfo.GetGlobalType: String;
begin
  Result := LWCOMPINFO_GLOBAL ;
end;

{ TBackdropInfo }

function TBackdropInfo.GetGlobalType: String;
begin
  Result := LWBACKDROPINFO_GLOBAL ;
end;

procedure TBackdropInfo.Backdrop
                        (       Time  : TLWTime ;
                          const Ray   : array of Double ;
                                Color : array of Double);
begin
  PLWBackdropInfo(FGlobal).Backdrop(Time, Ray, Color);
end;

procedure TBackdropInfo.Color
                        (       Time   : TLWTime ;
                                Zenith ,
                                Sky    ,
                                Ground ,
                                Nadir  : array of Double);
begin
  PLWBackdropInfo(FGlobal).Color(Time, Zenith, Sky, Ground, Nadir);
end;

procedure TBackdropInfo.Squeeze
                        (       Time   : TLWTime ;
                                Sky    ,
                                Ground : PDouble);
begin
  PLWBackdropInfo(FGlobal).Squeeze(Time, Sky, Ground);
end;

{ TFogInfo }

function TFogInfo.GetGlobalType: String;
begin
  Result := LWFOGINFO_GLOBAL ;
end;

function TFogInfo.MinDist
                  (      Time : TLWTime ) : Double;
begin
  Result := PLWFogInfo(FGlobal).MinDist(Time);
end;

function TFogInfo.MaxDist
                  (      Time : TLWTime ) : Double;
begin
  Result := PLWFogInfo(FGlobal).MaxDist(Time);
end;

function TFogInfo.MinAmt
                  (      Time : TLWTime ) : Double;
begin
  Result := PLWFogInfo(FGlobal).MinAmt(Time);
end;

function TFogInfo.MaxAmt
                  (      Time : TLWTime ) : Double;
begin
  Result := PLWFogInfo(FGlobal).MaxAmt(Time);
end;

procedure TFogInfo.Color
                  (      Time : TLWTime ;
                         Col  : array of Double ) ;
begin
  PLWFogInfo(FGlobal).Color(Time, Col);
end;

{ TInterfaceInfo }

function TInterfaceInfo.GetGlobalType : String;
begin
  Result := LWINTERFACEINFO_GLOBAL;
end;

function TInterfaceInfo.ItemFlags
                        (        Item : PLWItem ) : Uint32;
begin
  Result := PLWInterfaceInfo(FGlobal).ItemFlags(Item);
end;

procedure TInterfaceInfo.SchemaPos
                        (        Item : PLWItem ;
                                 X    ,
                                 Y    : PDouble ) ;
begin
  PLWInterfaceInfo(FGlobal).SchemaPos(Item, X, Y );
end;

function TInterfaceInfo.ItemVis
                        (        Item : PLWItem ) : Integer;
begin
  Result := PLWInterfaceInfo(FGlobal).ItemVis(Item);
end;

function TInterfaceInfo.ItemColor
                        (        Item : PLWItem ) : Integer;
begin
  Result := PLWInterfaceInfo(FGlobal).ItemColor(Item);
end;

procedure TInterfaceInfo.SetItemColorIndex
                        (        Item  : PLWItem ;
                                 Color : Integer ) ;
begin
  PLWInterfaceInfo(FGlobal).SetItemColorIndex(Item, Color );
end;

procedure TInterfaceInfo.SetItemColorCustom
                        (        Item  : PLWItem ;
                                 Color : PDouble ) ;
begin
  PLWInterfaceInfo(FGlobal).SetItemColorCustom(Item, Color );
end;

procedure TInterfaceInfo.DefaultItemTypeColor
                        (        Item  : PLWItem ;
                                 Color : PSingle ;
                                 Set_  : Integer ) ;
begin
  PLWInterfaceInfo(FGlobal).DefaultItemTypeColor(Item, Color, Set_ );
end;

procedure TInterfaceInfo.ItemColorRGBA
                        (        Item  : PLWItem ;
                                 State : UInt32  ;
                                 RGBA  : TLWFVector4 ) ;
begin
  PLWInterfaceInfo(FGlobal).ItemColorRGBA(Item, State , RGBA );
end;

function TInterfaceInfo.ItemIconScale
                        (        Item : PLWItem ) : Single;
begin
  Result := PLWInterfaceInfo(FGlobal).ItemIconScale(Item);
end;

{ TViewportInfo }

function  TViewportInfo.GetGlobalType                   : String ;
begin
  Result := LWVIEWPORTINFO_GLOBAL;
end;

function TViewportInfo.Type_
                       (    Index : Integer ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).Type_(Index);
end;

function TViewportInfo.Flags
                       (    Index : Integer ) :  UInt32;
begin
  Result := PLWViewportInfo(FGlobal).Flags(Index);
end;

procedure TViewportInfo.Pos
                       (    Index : Integer    ;
                            Spot  : TLWDVector ) ;
begin
  PLWViewportInfo(FGlobal).Pos(Index, Spot);
end;

procedure TViewportInfo.Xfrm
                       (    Index : Integer         ;
                            Mat   : array of Double ) ;
begin
  PLWViewportInfo(FGlobal).Xfrm(Index, Mat);
end;

procedure TViewportInfo.Clip
                       (    Index  : Integer ;
                            Hither ,
                            Yon    : PDouble ) ;
begin
  PLWViewportInfo(FGlobal).Clip(Index, Hither, Yon);
end;

procedure TViewportInfo.Rect
                       (    Index  : Integer  ;
                            Left   ,
                            Top    ,
                            Width  ,
                            Height : PInteger ) ;
begin
  PLWViewportInfo(FGlobal).Rect(Index, Left, Top, Width, Height);
end;

function TViewportInfo.ViewLevel
                       (    Index : Integer ) :  Integer;
begin
  Result := PLWViewportInfo(FGlobal).ViewLevel(Index);
end;

function TViewportInfo.Projection
                       (    Index         : Integer ;
                            Projection    ,
                            InvProjection : TLWDMatrix4 ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).Projection(Index, Projection, InvProjection);
end;

function TViewportInfo.Modelview
                       (    Index        : Integer ;
                            Modelview    ,
                            InvModelView : TLWDMatrix4 ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).Modelview(Index, Modelview, InvModelView);
end;

function TViewportInfo.Project
                       (    Index : Integer    ;
                            World : TLWDVector ;
                            WinX  ,
                            WinY  ,
                            WinZ  : PDouble    ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).Project(Index, World, WinX, WinY, WinZ);
end;

function TViewportInfo.UnProject
                       (    Index : Integer    ;
                            WinX  ,
                            WinY  ,
                            WinZ  : Double     ;
                            World : TLWDVector ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).UnProject(Index, WinX, WinY, WinZ, World);
end;

function TViewportInfo.PixelSize
                       (      Index  : Integer        ;
                              Pixels : Double         ;
                              RefPos : array of Double) : Double ;
begin
  Result := PLWViewportInfo(FGlobal).PixelSize(Index, Pixels, RefPos);
end;

function  TViewportInfo.HandleSize
                        (      Index  : Integer        ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).HandleSize(Index);
end;

function TViewportInfo.GridSize
                        (      Index  : Integer        ) : Double;
begin
  Result := PLWViewportInfo(FGlobal).GridSize(Index);
end;

function TViewportInfo.ViewItem
                        (      Index  : Integer        ) : PLWItem;
begin
  Result := PLWViewportInfo(FGlobal).ViewItem(Index);
end;

function TViewportInfo.GridType
                        (      Index  : Integer        ) : Integer;
begin
  Result := PLWViewportInfo(FGlobal).GridType(Index);
end;

{ TGlobalPool }

function TGlobalPool.GetGlobalType: String;
begin
  Result := LWGLOBALPOOL_GLOBAL;
end;

function TGlobalPool.First
                     ( const Void                   ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).First(Void);
end;

function TGlobalPool.Next
                     (       MemChunk : PLWMemChunk ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).Next(MemChunk);
end;

function TGlobalPool.ID
                     (       MemChunk : PLWMemChunk ) : PChar;
begin
  Result := PLWGlobalPool(FGlobal).ID(MemChunk);
end;

function TGlobalPool.Size
                     (       MemChunk : PLWMemChunk ) : Integer;
begin
  Result := PLWGlobalPool(FGlobal).Size(MemChunk);
end;

function TGlobalPool.Find
                     ( const InID     : PChar       ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).Find(InID);
end;

function TGlobalPool.Create
                     ( const InID     : PChar       ;
                             InSize   : Integer     ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).Create(InID, InSize);
end;

{ TGlobalRenderPool }

function TGlobalRenderPool.GetGlobalType: String;
begin
  Result := LWGLOBALPOOL_RENDER_GLOBAL ;
end;

function TGlobalRenderPool.First
                           ( const Void                   ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).First(Void);
end;

function TGlobalRenderPool.Next
                           (       MemChunk : PLWMemChunk ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).Next(MemChunk);
end;

function TGlobalRenderPool.ID
                           (       MemChunk : PLWMemChunk ) : PChar;
begin
  Result := PLWGlobalPool(FGlobal).ID(MemChunk);
end;

function TGlobalRenderPool.Size
                           (       MemChunk : PLWMemChunk ) : Integer;
begin
  Result := PLWGlobalPool(FGlobal).Size(MemChunk);
end;

function TGlobalRenderPool.Find
                           ( const InID     : PChar       ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).Find(InID);
end;

function TGlobalRenderPool.Create
                           ( const InID     : PChar       ;
                                   InSize   : Integer     ) : PLWMemChunk;
begin
  Result := PLWGlobalPool(FGlobal).Create(InID, InSize);
end;

end.

